pub fn try_append_value(&mut self, value: impl AsRef<T::Native>) -> Result<(), ArrowError> {
        let v: &[u8] = value.as_ref().as_ref();
        let length: u32 = v.len().try_into().map_err(|_| {
            ArrowError::InvalidArgumentError(format!("String length {} exceeds u32::MAX", v.len()))
        })?;

        if length <= MAX_INLINE_VIEW_LEN {
            let mut view_buffer = [0; 16];
            view_buffer[0..4].copy_from_slice(&length.to_le_bytes());
            view_buffer[4..4 + v.len()].copy_from_slice(v);
            self.views_buffer.push(u128::from_le_bytes(view_buffer));
            self.null_buffer_builder.append_non_null();
            return Ok(());
        }
  // ...
}

    #[test]
    fn test_string_max_deduplication_len() {
        let value_1 = "short";
        let value_2 = "not so similar string but long";
        let value_3 = "1234567890123";

        let max_deduplication_len = MAX_INLINE_VIEW_LEN * 2;

        let mut builder = StringViewBuilder::new()
            .with_deduplicate_strings()
            .with_max_deduplication_len(max_deduplication_len);

        assert!(value_1.len() < MAX_INLINE_VIEW_LEN.as_usize());
        assert!(value_2.len() > max_deduplication_len.as_usize());
        assert!(
            value_3.len() > MAX_INLINE_VIEW_LEN.as_usize()
                && value_3.len() < max_deduplication_len.as_usize()
        );

        // append value1 (short), expect it is inlined and deduplicated
        builder.append_value(value_1); // view 0
        builder.append_value(value_1); // view 1
        // append value2, expect second copy is not deduplicated as it exceeds max_deduplication_len
        builder.append_value(value_2); // view 2
        builder.append_value(value_2); // view 3
        // append value3, expect second copy is deduplicated
        builder.append_value(value_3); // view 4
        builder.append_value(value_3); // view 5

        let array = builder.finish();

        // verify
        let v2 = ByteView::from(array.views()[2]);
        let v3 = ByteView::from(array.views()[3]);
        assert_eq!(v2.buffer_index, v3.buffer_index); // stored in same buffer
        assert_ne!(v2.offset, v3.offset); // different offsets --> not deduplicated

        let v4 = ByteView::from(array.views()[4]);
        let v5 = ByteView::from(array.views()[5]);
        assert_eq!(v4.buffer_index, v5.buffer_index); // stored in same buffer
        assert_eq!(v4.offset, v5.offset); // same offsets --> deduplicated
    }

    #[test]
    fn test_string_max_deduplication_len() {
        let value_1 = "short";
        let value_2 = "not so similar string but long";
        let value_3 = "1234567890123";

        let max_deduplication_len = MAX_INLINE_VIEW_LEN * 2;

        let mut builder = StringViewBuilder::new()
            .with_deduplicate_strings()
            .with_max_deduplication_len(max_deduplication_len);

        assert!(value_1.len() < MAX_INLINE_VIEW_LEN.as_usize());
        assert!(value_2.len() > max_deduplication_len.as_usize());
        assert!(
            value_3.len() > MAX_INLINE_VIEW_LEN.as_usize()
                && value_3.len() < max_deduplication_len.as_usize()
        );

        // append value1 (short), expect it is inlined and deduplicated
        builder.append_value(value_1); // view 0
        builder.append_value(value_1); // view 1
        // append value2, expect second copy is not deduplicated as it exceeds max_deduplication_len
        builder.append_value(value_2); // view 2
        builder.append_value(value_2); // view 3
        // append value3, expect second copy is deduplicated
        builder.append_value(value_3); // view 4
        builder.append_value(value_3); // view 5

        let array = builder.finish();

        // verify
        let v2 = ByteView::from(array.views()[2]);
        let v3 = ByteView::from(array.views()[3]);
        assert_eq!(v2.buffer_index, v3.buffer_index); // stored in same buffer
        assert_ne!(v2.offset, v3.offset); // different offsets --> not deduplicated

        let v4 = ByteView::from(array.views()[4]);
        let v5 = ByteView::from(array.views()[5]);
        assert_eq!(v4.buffer_index, v5.buffer_index); // stored in same buffer
        assert_eq!(v4.offset, v5.offset); // same offsets --> deduplicated
    }

        // Deduplication if:
        // (1) deduplication is enabled.
        // (2) len > `MAX_INLINE_VIEW_LEN` and len < `max_deduplication_len`
        if let Some((mut ht, hasher)) = self.string_tracker.take() {
            if self
                .max_deduplication_len
                .map(|max_len| length > max_len)
                .unwrap_or(false)
            {
                let hash_val = hasher.hash_one(v);
                let hasher_fn = |v: &_| hasher.hash_one(v);

                let entry = ht.entry(
                    hash_val,
                    |idx| {
                        let stored_value = self.get_value(*idx);
                        v == stored_value
                    },
                    hasher_fn,
                );
                match entry {
                    Entry::Occupied(occupied) => {
                        // If the string already exists, we will directly use the view
                        let idx = occupied.get();
                        self.views_buffer.push(self.views_buffer[*idx]);
                        self.null_buffer_builder.append_non_null();
                        self.string_tracker = Some((ht, hasher));
                        return Ok(());
                    }
                    Entry::Vacant(vacant) => {
                        // o.w. we insert the (string hash -> view index)
                        // the idx is current length of views_builder, as we are inserting a new view
                        vacant.insert(self.views_buffer.len());
                    }
                }
            }
            self.string_tracker = Some((ht, hasher));
        }

let can_deduplicate = if self.string_tracker.is_some() {
            match self.max_deduplication_len {
                Some(max_deduplication_len) => length <= max_deduplication_len,
                None => true,
            }
        } else {
            false
        };

        let can_deduplicate = self.string_tracker.is_some()
            && self
                .max_deduplication_len
                .map(|max_length| length <= max_length)
                .unwrap_or_default();

        if can_deduplicate {
            if let Some((mut ht, hasher)) = self.string_tracker.take() {

        if can_deduplicate && let Some((mut ht, hasher)) = self.string_tracker.take() {